static void dfs(int cnt, int weight) {
		if (cnt > n || weight < 0 || weight > 15001 || chk[cnt][weight])
			return;

		chk[cnt][weight] = true; // cnt 번째까지의 추를 고려했을 때의 가능한 무게

		if (cnt == n)
			return;

		dfs(cnt + 1, weight + w[cnt]); // 추를 올리거나
		dfs(cnt + 1, weight); // 추를 사용하지 않거나
		dfs(cnt + 1, Math.abs(weight - w[cnt])); // 추를 구슬쪽에 올리거나
	}

dp[0] = 0;
        dp[1] = 1;
        dp[2] = 2;
        dp[3] = 3;

        for (int i = 4; i <= n; i++) {
            dp[i] = i;
            for (int j = 1; j * j <= i; j++) { // 제곱수 이전이 있다면 그 이전꺼 + 제곱수 1개
                dp[i] = Math.min(dp[i], dp[i - j * j] + 1);
            }
        }

static void run() {
		while (true) {
			if (map[c.y][c.x] == 0) {
				map[c.y][c.x] = 2;
				res++;
			}

			boolean chk = false;

			for (int d = 0; d < 4; d++) { // 4방향 중 청소할 곳 있는지 탐색
				int dy = c.y + dir[d][0];
				int dx = c.x + dir[d][1];
				if (dy < 0 || dy >= n || dx < 0 || dx >= m)
					continue;
				if (map[dy][dx] == 0) {
					chk = true;
					break;
				}
			}
			if (chk) { // 청소할 곳이 있다면 왼쪽으로 90도 돌아서 확인
				c.dir = turn[c.dir];
				int dy = c.y + dir[c.dir][0];
				int dx = c.x + dir[c.dir][1];
				if (dy < 0 || dy >= n || dx < 0 || dx >= m)
					continue;
				if (map[dy][dx] == 0) {
					c.y = dy;
					c.x = dx;
				}
			} else { // 청소할 곳이 없다면 뒤로 한칸 이동
				int dy = c.y + dir[round[c.dir]][0];
				int dx = c.x + dir[round[c.dir]][1];
				if (dy < 0 || dy >= n || dx < 0 || dx >= m || map[dy][dx] == 1)
					return;
				else {
					c.y = dy;
					c.x = dx;
				}
			}
		}
	}

static void bfs(boolean[][] visited, Queue<int[]> q) {
	    int[][] time = new int[n][n]; // 각 칸별 감염되는 시간을 저장할 배열
	    int max = 0;

	    while (!q.isEmpty()) {
	        int[] cur = q.poll();
	        for (int d = 0; d < 4; d++) {
	            int dy = cur[0] + dir[d][0];
	            int dx = cur[1] + dir[d][1];

	            if (dy >= 0 && dy < n && dx >= 0 && dx < n && map[dy][dx] != 1 && !visited[dy][dx]) {
	                visited[dy][dx] = true; // 감염 가능한 구역을 찾아서 감염시키고 시간 저장
	                time[dy][dx] = time[cur[0]][cur[1]] + 1;
	                q.add(new int[] { dy, dx });
	            }
	        }
	    }

        // 모든 탐색이 끝나면 전 지역을 감염시켰는지 확인
	    boolean success = true;
	    for (int i = 0; i < n; i++) {
	        for (int j = 0; j < n; j++) {
	            if (map[i][j] == 0) {
	                if (!visited[i][j]) {
	                    success = false;
	                    break;
	                } else {
	                    max = Math.max(max, time[i][j]);
	                }
	            }
	        }
	    }

	    if (success) { // 모두 감염 시켰다면 res 갱신
	        res = Math.min(res, max);
	    }
	}

static void combination(int cnt, int start) { // 처음 활성화시키는 바이러스 조합 구하고 탐색
		if (cnt == m) {
			boolean[][] visited = new boolean[n][n];
			Queue<int[]> q = new ArrayDeque<>();
			for (int i = 0; i < m; i++) {
				int[] cur = virus.get(num[i]);
				visited[cur[0]][cur[1]] = true;
				q.add(cur);
			}
			bfs(visited, q);
			return;
		}

		for (int i = start; i < virus.size(); i++) {
			num[cnt] = i;
			combination(cnt + 1, i + 1);
		}
	}

int[] dp = new int[31]; // 최대 30칸 까지
		dp[0] = 1;
		dp[1] = 0;
		dp[2] = 3;

		for (int i = 4; i <= n; i += 2) { // 점화식을 이용한 dp 풀이
			dp[i] = 3 * dp[i - 2];
			for (int j = 4; j <= i; j += 2) {
				dp[i] += 2 * dp[i - j];
			}
		}